{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy and basic mathematics review\n",
    "\n",
    "Before learning about what regression and classification are, we will do a review of key mathematical concepts from linear algebra and calculus. These fundamentals will be helpful to understand some of the theoretical materials of the next few guides. Additionally, we will introduce Numpy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy\n",
    "\n",
    "We will be working a lot with Numpy, a Python library which adds support for large-scale vector and matrices, as well as fast and efficient computation of important mathematical functions operating on data. \n",
    "\n",
    "Numpy is a very large library with many convenient functions. A review of them is beyond the scope of this chapter. We will introduce relevant numpy functions in future sessions as we go, depending on when we need them. A good non-comprehensive review can also be found [here](https://cs231n.github.io/python-numpy-tutorial/). If you are unfamiliar with Numpy, it will be very helpful to go through the exercises in that tutorial, which also contain a short Python review. \n",
    "\n",
    "In the following section, we will just review some of the most common operations briefly, focusing on the ones that will help us in the next section.\n",
    "\n",
    "To start, import numpy (frequently as `np` to make calls shorter)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy has many convenience functions for generating lists of numbers. For example, to create a list of all integers between 0 and 10:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `numpy.linspace` function gives you a linear interpolation of `n` numbers between two endpoints."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.        ,  1.42857143,  2.85714286,  4.28571429,  5.71428571,\n",
       "        7.14285714,  8.57142857, 10.        ])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 10, 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectors\n",
    "\n",
    "Vectors can be represented using `numpy.array`. So for example, to represent the vector:\n",
    "\n",
    "$$\n",
    "v = \\begin{bmatrix} 2 \\\\ 3 \\\\ 1 \\end{bmatrix}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3, 1])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([2, 3, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When two vectors of equal length are added, the elements are added point-wise.\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix} 2 \\\\ 3 \\\\ 1 \\end{bmatrix} + \\begin{bmatrix} 0 \\\\ 2 \\\\ -2 \\end{bmatrix} = \\begin{bmatrix} 2 \\\\ 5 \\\\ -1 \\end{bmatrix}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2  5 -1]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([2, 3, 1])\n",
    "b = np.array([0, 2, -2])\n",
    "c = a + b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A vector can be multiplied element-wise by a number (called a \"scalar\"). For example:\n",
    "    \n",
    "\n",
    "$$\n",
    "3 \\begin{bmatrix} 2 \\\\ 3 \\\\ 1 \\end{bmatrix} = \\begin{bmatrix} 6 \\\\ 9 \\\\ 3 \\end{bmatrix}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 9, 3])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 * np.array([2,3,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A dot product is defined as the sum of the element-wise products of two equal-sized vectors. For two vectors $a$ and $b$, it is denoted as $a \\cdot b$ or as $a b^T$ (where T refers to the transpose operation, introduced further down this notebook.\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix} 1 & -2 & 2 \\end{bmatrix} \\begin{bmatrix} 0 \\\\ 2 \\\\ 3 \\end{bmatrix} = 2\n",
    "$$\n",
    "\n",
    "In other words, it's:\n",
    "\n",
    "$$\n",
    "1 \\cdot 0 + -2 \\cdot 2 + 2 \\cdot 3 = 2\n",
    "$$\n",
    "\n",
    "This can be calculated with the `numpy.dot` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,-2,2])\n",
    "b = np.array([0,2,3])\n",
    "c = np.dot(a, b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or the shorter way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "c = a.dot(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrices\n",
    "\n",
    "A matrix is a rectangular array of numbers. For example, consider the following 2x3 matrix:\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix} 2 & 3 & 1 \\\\ 0 & 4 & -2 \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "Note that we always denote the size of the matix as rows x columns. So a 2x3 matrix has two rows and 3 columns.\n",
    "\n",
    "Numpy can create matrices from normal Python lists using `numpy.matrix`. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 2,  3,  1],\n",
       "        [ 0,  4, -2]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.matrix([[2,3,1],[0, 4,-2]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To instantiate a matrix of all zeros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To instantiate a matrix of all ones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.],\n",
       "       [1., 1.]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((2, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In linear algebra, a square matrix whose elements are all zeros, except the diagonals, which are ones, is called an \"identity matrix.\" \n",
    "\n",
    "For example:\n",
    "\n",
    "$$\n",
    "\\mathbf I =\n",
    "\\begin{bmatrix}\n",
    "1 & 0 & 0 \\\\\n",
    "0 & 1 & 0 \\\\\n",
    "0 & 0 & 1\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "is a 3x3 identity matrix. The reason why it is called an identity matrix is that it is analagous to multiplying a scalar by 1. A matrix multiplied by an identity matrix is unchanged. \n",
    "\n",
    "$$\n",
    "\\mathbf I v = v\n",
    "$$\n",
    "\n",
    "To instantiate an identity matrix, use `numpy.eye`. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice when you multiple an identity matrix by another matrix, the result is the same as the original matrix. This goes in either order. Basically, the identity matrix is like $\\times 1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "original matrix = \n",
      " [[ 9  5  6]\n",
      " [-1  0  5]\n",
      " [-2  4  2]]\n",
      "I * M = \n",
      " [[ 9.  5.  6.]\n",
      " [-1.  0.  5.]\n",
      " [-2.  4.  2.]]\n",
      "M * I = \n",
      " [[ 9.  5.  6.]\n",
      " [-1.  0.  5.]\n",
      " [-2.  4.  2.]]\n"
     ]
    }
   ],
   "source": [
    "M = np.matrix([[9,5,6],[-1,0,5],[-2,4,2]])\n",
    "I = np.eye(3)\n",
    "print(\"original matrix = \\n\", M)\n",
    "M2 = I * M\n",
    "print(\"I * M = \\n\", M2)\n",
    "M3 = M * I\n",
    "print(\"M * I = \\n\", M3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To instantiate a matrix of random elements (between 0 and 1), you can use `numpy.random`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.13425988 0.99250082 0.52730459]\n",
      " [0.09945505 0.42777824 0.52474797]]\n"
     ]
    }
   ],
   "source": [
    "A = np.random.random((2, 3))\n",
    "print(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Transposition is to reverse the axes of two matrices. So the element at `i,j` in the transposed matrix is equal to the element at `j,i` in the original. The matrix A transposed is denoted as $A^T$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.13425988 0.09945505]\n",
      " [0.99250082 0.42777824]\n",
      " [0.52730459 0.52474797]]\n"
     ]
    }
   ],
   "source": [
    "A_transpose = np.transpose(A)\n",
    "print(A_transpose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can also be done with the shorthand `.T` operation, as in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.13425988 0.09945505]\n",
      " [0.99250082 0.42777824]\n",
      " [0.52730459 0.52474797]]\n"
     ]
    }
   ],
   "source": [
    "A_transpose = A.T\n",
    "print(A_transpose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrix operations and properties\n",
    "\n",
    "Like regular vectors, matrices are added point-wise (or element-wise) and must be of the same size. So for example:\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix} 4 & 3 \\\\ 3 & -1 \\\\ -2 & 1 \\end{bmatrix} + \\begin{bmatrix} -2 & 1 \\\\ 5 & 3 \\\\ 1 & 0 \\end{bmatrix} = \\begin{bmatrix} 2 & 4 \\\\ 8 & 2 \\\\ -1 & 1 \\end{bmatrix} \n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  4]\n",
      " [ 8  2]\n",
      " [-1  1]]\n"
     ]
    }
   ],
   "source": [
    "a = np.matrix([[4, 3],[3,-1],[-2,1]])\n",
    "b = np.matrix([[-2, 1],[5,3],[1,0]])\n",
    "c = a + b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also like vectors, matrices can be multiplied element-wise by a scalar.\n",
    "\n",
    "$$\n",
    "-2 \\begin{bmatrix} 1 & -2 & 0 \\\\ 6 & 4 & -2 \\end{bmatrix} = \\begin{bmatrix} -2 & 4 & 0 \\\\ -12 & -8 & 4 \\end{bmatrix} \n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ -2,   4,   0],\n",
       "        [-12,  -8,   4]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.matrix([[1,-2,0],[6,4,-2]])\n",
    "-2 * a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To multiply two matrices together, you take the dot product of each row of the first matrix and each column of the second matrix, as in:  \n",
    "\n",
    "![matrix multiplication via wikipedia](https://wikimedia.org/api/rest_v1/media/math/render/svg/780671bdfb3fab93187156d2c226df6fe36746fe)\n",
    "\n",
    "So in order to multiply matrices $A$ and $B$ together, as in $C = A \\dot B$, $A$ must have the same number of columns as $B$ has rows. For example:\n",
    "\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix} 1 & -2 & 0 \\\\ 6 & 4 & -2 \\end{bmatrix} * \\begin{bmatrix} 4 & -1 \\\\ 0 & -2 \\\\ 1 & 3 \\end{bmatrix} = \\begin{bmatrix} 4 & 3 \\\\ 22 & -20 \\end{bmatrix} \n",
    "$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  4   3]\n",
      " [ 22 -20]]\n"
     ]
    }
   ],
   "source": [
    "a = np.matrix([[1,-2,0],[6,4,-2]])\n",
    "b = np.matrix([[4,-1],[0,-2],[1,3]])\n",
    "c = a * b\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Hadamard product of two matrices differs from normal multiplication in that it is the element-wise multiplication of two matrices. \n",
    "\n",
    "$$\n",
    "\\mathbf A \\odot B =\n",
    "\\begin{bmatrix}\n",
    "A_{1,1} B_{1,1} & \\dots & A_{1,n} B_{1,n} \\\\\n",
    "\\vdots & \\dots & \\vdots \\\\\n",
    "A_{m,1} B_{m,1} & \\dots & A_{m,n} B_{m,n}\n",
    "\\end{bmatrix}\n",
    "$$\n",
    "\n",
    "So for example:\n",
    "\n",
    "$$\n",
    "\\begin{bmatrix} 3 & 1 \\\\ 0 & 5 \\end{bmatrix} \\odot \\begin{bmatrix} -2 & 4 \\\\ 1 & -2 \\end{bmatrix} = \\begin{bmatrix} -6 & 4 \\\\ 0 & -10 \\end{bmatrix} \n",
    "$$\n",
    "\n",
    "To calculate this with numpy, simply instantiate the matrices with `numpy.array` instead of `numpy.matrix` and it will use element-wise multiplication by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ -6,   4],\n",
       "       [  0, -10]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[3,1],[0,5]])\n",
    "b = np.array([[-2,4],[1,-2]])\n",
    "np.multiply(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "A function is an equation which shows the value of some expression which depends on or more variables. For example:\n",
    "\n",
    "$$\n",
    "f(x) = 3x^2 - 5x + 9\n",
    "$$\n",
    "\n",
    "So for example, at $x=2$, $f(2)=11$. We will be encountering functions constantly. A neural network is one very big function.\n",
    "\n",
    "With functions, in machine learning, we often make a distinction between \"variables\" and \"parameters\".  The variable is that part of the equation which can vary, and the output depends on it. So the above function depends on $x$. The coefficients in the above function (3, -5, 9) are sometimes called parameters because they are characterize the shape of the function, but are held fixed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    return 3*(x**2)-5*x+9\n",
    "\n",
    "f(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Derivatives\n",
    "\n",
    "The derivative of a function $f(x)$ is the instantaneous slope of the function at a given point, and is denoted as $f^\\prime(x)$.\n",
    "\n",
    "\n",
    "$$f^\\prime(x) = \\lim_{\\Delta x\\to 0} \\frac{f(x + \\Delta x) - f(x)}{\\Delta x} $$\n",
    "\n",
    "The derivative of $f$ with respect to $x$ can also be denoted as $\\frac{df}{dx}$.\n",
    "\n",
    "The derivative can be interpreted as the slope of a function at any point, as in the following [video clip](https://en.wikipedia.org/wiki/Derivative), which shows that the limit converges upon the true slope as $\\Delta x$ approaches 0.\n",
    "\n",
    "![slope](https://upload.wikimedia.org/wikipedia/commons/c/cc/Tangent_animation.gif)\n",
    "\n",
    "The derivative of a polynomial function is given below: \n",
    "\n",
    "$$\n",
    "f(x) = a x ^ b\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\frac{df}{dx} = b a x^{b-1}\n",
    "$$\n",
    "\n",
    "For example, let:\n",
    "\n",
    "$$\n",
    "f(x) = -2 x^3\n",
    "$$\n",
    "\n",
    "then:\n",
    "\n",
    "$$\n",
    "\\frac{df}{dx} = -6 x^2\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-16\n",
      "-24\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "    return -2*(x**3)\n",
    "\n",
    "def f_deriv(x):\n",
    "    return -6*(x**2)\n",
    "\n",
    "print(f(2))\n",
    "print(f_deriv(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The derivative of any constant is 0. To see why, let:\n",
    "\n",
    "$$\n",
    "f(x) = C\n",
    "$$\n",
    "\n",
    "Then:\n",
    "\n",
    "$$\n",
    "f^\\prime(x) = \\lim_{\\Delta x\\to 0} \\frac{f(x + \\Delta x) - f(x)}{\\Delta x} \\\\\n",
    "f^\\prime(x) = \\lim_{\\Delta x\\to 0} \\frac{C - C}{\\Delta x} \\\\\n",
    "f^\\prime(x) = \\lim_{\\Delta x\\to 0} \\frac{0}{\\Delta x} \\\\\n",
    "f^\\prime(x) = 0\n",
    "$$\n",
    "\n",
    "### Properties of derivatives\n",
    "\n",
    "Derivatives are commutative. That is, the derivative of a sum is the sum of the derivatives. In other words:\n",
    "\n",
    "Let $g$ and $h$ be functions. Then:\n",
    "\n",
    "$$\n",
    "\\frac{d}{dx}(g + h) = \\frac{dg}{dx} +\\frac{dh}{dx}\n",
    "$$\n",
    "\n",
    "Similarly, constants can be factored out of derivatives, using the following property:\n",
    "\n",
    "$$\n",
    "\\frac{d}{dx}(C f(x)) = C \\frac{df}{dx}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chain rule\n",
    "\n",
    "Functions can be composites of multiple functions. For example, consider the function:\n",
    "\n",
    "$$\n",
    "f(x) = (4x-5)^3\n",
    "$$\n",
    "\n",
    "This function can be broken down by letting:\n",
    "\n",
    "$$\n",
    "h(x) = 4x-5 \\\\\n",
    "g(x) = x^3 \\\\\n",
    "f(x) = g(h(x)) \n",
    "$$\n",
    "\n",
    "The chain rule states that the derivative of a composite function $g(h(x))$ is:\n",
    "\n",
    "$$\n",
    "f^\\prime(x) = g^\\prime(h(x)) h^\\prime(x)\n",
    "$$\n",
    "\n",
    "Another way of expressing this is:\n",
    "\n",
    "\n",
    "$$\n",
    "\\frac{df}{dx} = \\frac{dg}{dh} \\frac{dh}{dx}\n",
    "$$\n",
    "\n",
    "Since $f$ and $g$ are both polynomials we find, we can easily calculate that:\n",
    "\n",
    "$$\n",
    "g^\\prime(x) = 3x^2 \\\\\n",
    "h^\\prime(x) = 4\n",
    "$$\n",
    "\n",
    "and therefore:\n",
    "\n",
    "$$\n",
    "f^\\prime(x) = g^\\prime(h(x)) h^\\prime(x) \\\\\n",
    "f^\\prime(x) = g^\\prime(4x-5) \\cdot 4 \\\\\n",
    "f^\\prime(x) = 3 \\cdot (4x-5)^2 \\cdot 4 \\\\\n",
    "f^\\prime(x) = 12 \\cdot (4x-5)^2\n",
    "$$\n",
    "\n",
    "The chain rule is extremely important to the study of neural networks, because it is what allows us to find the derivative of the network's cost function analytically. We will see more about this in the next notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def h(x):\n",
    "    return 4*x-5\n",
    "\n",
    "def g(x):\n",
    "    return x**3\n",
    "\n",
    "def f(x):\n",
    "    return g(h(x))\n",
    "\n",
    "def h_deriv(x):\n",
    "    return 4\n",
    "\n",
    "def g_deriv(x):\n",
    "    return 3*(x**2)\n",
    "\n",
    "def f_deriv(x):\n",
    "    return g_deriv(h(x)) * h_deriv(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1331"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "108"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f_deriv(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multivariable functions\n",
    "\n",
    "A function may have more than one variable. For example:\n",
    "\n",
    "$$\n",
    "f(X) = w_1 x_1 + w_2 x_2 + w_3 x_3 + ... + w_n x_n + b \n",
    "$$\n",
    "\n",
    "or using sum notation:\n",
    "\n",
    "$$\n",
    "f(X) = b + \\sum_i w_i x_i\n",
    "$$\n",
    "\n",
    "One useful trick to simplify this formula is to append a $1$ to the input vector $X$, so that:\n",
    "\n",
    "$$\n",
    "X = \\begin{bmatrix} x_1 & x_2 & ... & x_n & 1 \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "and let $b$ just be an element in the weights vector, so:\n",
    "\n",
    "$$\n",
    "W = \\begin{bmatrix} w_1 & w_2 & ... & w_n  & b \\end{bmatrix}\n",
    "$$\n",
    "\n",
    "So then we can rewrite the function as:\n",
    "\n",
    "$$\n",
    "f(X) = W X^T\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A partial derivative of a multivariable function is the derivative of the function with respect to just one of the variables, holding all the others constant.\n",
    "\n",
    "The partial derivative of $f$ with respect to $x_i$ is denoted as $\\frac{\\partial f}{\\partial x_i}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gradient\n",
    "\n",
    "The [gradient](https://en.wikipedia.org/wiki/Gradient) of a function is the vector containing each of its partial derivatives at point $x$.\n",
    "\n",
    "$$\n",
    "\\nabla f(X) = \\left[ \\frac{\\partial f}{\\partial x_1}, \\frac{\\partial f}{\\partial x_2}, ..., \\frac{\\partial f}{\\partial x_n}  \\right]\n",
    "$$\n",
    "\n",
    "We will look more closely at the gradient later when we get into how neural networks are trained."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting\n",
    "\n",
    "We introduced plotting in the previous guide. The example below recreates that plot, except using numpy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x1088aa860>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1086a0198>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "X = np.arange(-5, 5, 0.1)\n",
    "Y = np.sin(X)\n",
    "\n",
    "# make the figure\n",
    "plt.figure(figsize=(6,6))\n",
    "plt.plot(X, Y)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y = sin(x)')\n",
    "plt.title('My plot title')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
